package com.example.service;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.common.PageResult;
import com.example.common.enums.ErrorCodeEnum;
import com.example.common.enums.RoleEnum;
import com.example.exception.CustomException;
import com.example.mapper.PetMapper;
import com.example.pojo.dto.PetQueryDto;
import com.example.pojo.entity.Account;
import com.example.pojo.entity.Pet;
import com.example.pojo.entity.PetShop;
import com.example.pojo.vo.PetQueryVo;
import com.example.utils.AccountUtils;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

/**
 * 宠物 service 层实现类
 */
@Service
public class PetServiceImpl extends ServiceImpl<PetMapper, Pet> implements PetService {


    @Resource
    private PetShopService petShopService;

    /**
     * 增加宠物
     *
     * @param pet 宠物
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void add(Pet pet) {
        // 1.校验参数
        if (pet == null) {
            throw new CustomException(ErrorCodeEnum.PARAM_LOST_ERROR);
        }
        this.checkPetParam(pet);
        // 2.将宠物类型数据存入数据库
        this.save(pet);
    }

    /**
     * 分页查询宠物
     *
     * @param pageNum  页码
     * @param pageSize 页大小
     * @param dto  条件
     * @return 分页结果
     */
    @Override
    public PageResult<PetQueryVo> pageQuery(Integer pageNum, Integer pageSize, PetQueryDto dto) {
        // 1.校验参数
        if (pageNum == null || pageNum < 1) {
            throw new CustomException(ErrorCodeEnum.PAGE_QUERY_NUM);
        }
        if (pageSize == null || pageSize < 1 || pageSize > 100) {
            throw new CustomException(ErrorCodeEnum.PAGE_QUERY_SIZE);
        }

        // 2.创建 MybatisPlus 分页对象
        IPage<PetQueryVo> pageObject = new Page<>(pageNum, pageSize);

        // 3.获取当前登录的用户
        Account currentLoginAccount = AccountUtils.getCurrentLoginAccount();
        if (currentLoginAccount == null || StrUtil.isBlank(currentLoginAccount.getRole())) {
            throw new CustomException(ErrorCodeEnum.GET_CUR_USER_ERROR);
        }
        // 4.当前登录的用户是宠物店，只查询自己的宠物
        String role = currentLoginAccount.getRole();
        if (RoleEnum.PETSHOP.name().equals(role)) {
            Integer shopId = this.petShopService.lambdaQuery()
                    .eq(PetShop::getUsername, currentLoginAccount.getUsername())
                    .one()
                    .getId();
            dto.setShopId(shopId);
        }
        // 5.分页查询宠物
        pageObject = this.getBaseMapper().pageQuery(pageObject, dto);
        // 6.构建分页结果并返回
        return new PageResult<>(
                pageObject.getTotal(),
                pageObject.getRecords()
        );
    }

    /**
     * 根据宠物id，查询宠物
     *
     * @param id 宠物id
     * @return 宠物
     */
    @Override
    public PetQueryVo queryById(Integer id) {
        // 1.校验参数
        if (id == null) {
            throw new CustomException(ErrorCodeEnum.PARAM_LOST_ERROR);
        }
        // 2.根据宠物id，查询宠物
        PetQueryDto dto = new PetQueryDto();
        dto.setId(id);
        List<PetQueryVo> petList = this.getBaseMapper().query(dto);
        // 3.返回宠物
        return petList.get(0);
    }

    /**
     * 根据条件查询全部宠物
     *
     * @param dto 条件
     * @return 宠物列表
     */
    @Override
    public List<PetQueryVo> queryAll(PetQueryDto dto) {
        return this.getBaseMapper().query(dto);
    }

    /**
     * 修改宠物
     *
     * @param pet 宠物
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(Pet pet) {
        // 1.校验参数
        if (pet == null) {
            throw new CustomException(ErrorCodeEnum.PARAM_LOST_ERROR);
        }
        if (pet.getId() == null) {
            throw new CustomException(ErrorCodeEnum.PARAM_LOST_ERROR);
        }
        this.checkPetParam(pet);

        // 2.根据宠物id，修改宠物
        this.updateById(pet);
    }

    /**
     * 根据宠物id，删除宠物
     *
     * @param id 宠物id
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delete(Integer id) {
        // 1.校验参数
        if (id == null) {
            throw new CustomException(ErrorCodeEnum.PARAM_LOST_ERROR);
        }
        // 2.根据宠物id，删除宠物
        this.removeById(id);
    }

    /**
     * 根据宠物id列表，删除宠物
     *
     * @param ids 宠物id列表
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteBatch(List<Integer> ids) {
        // 1.校验参数
        if (CollectionUtil.isEmpty(ids)) {
            throw new CustomException(ErrorCodeEnum.PARAM_LOST_ERROR);
        }
        // 2.根据宠物id列表，删除宠物
        this.removeBatchByIds(ids);
    }


    /**
     * 校验宠物名称、性别、宠物店id、宠物类型id
     *
     * @param pet 宠物
     */
    private void checkPetParam(Pet pet) {
        if (StrUtil.isBlank(pet.getName())) {
            throw new CustomException(ErrorCodeEnum.PET_NAME_ERROR);
        }
        if (StrUtil.isBlank(pet.getSex())) {
            throw new CustomException(ErrorCodeEnum.PET_SEX_ERROR);
        }
        if (pet.getShopId() == null) {
            throw new CustomException(ErrorCodeEnum.PET_SHOP_LOST_ERROR);
        }
        if (pet.getTypeId() == null) {
            throw new CustomException(ErrorCodeEnum.PET_TYPE_LOST_ERROR);
        }
        if (StrUtil.isBlank(pet.getStatus())) {
            throw new CustomException(ErrorCodeEnum.PET_STATUS_LOST_ERROR);
        }
        if (pet.getStore() == null) {
            throw new CustomException(ErrorCodeEnum.PET_STORE_LOST_ERROR);
        }
    }
}
